Spring ORM Hibernate এবং অন্যান্য ORM ফ্রেমওয়ার্কের জন্য একটি সহজ ইন্টিগ্রেশন সরবরাহ করে। CRUD (Create, Read, Update, Delete) অপারেশনগুলো Spring ORM এর মাধ্যমে সহজেই পরিচালনা করা যায়।

প্রয়োজনীয় ডিপেনডেন্সি

Spring ORM এবং Hibernate এর ডিপেনডেন্সিগুলো pom.xml ফাইলে যোগ করতে হবে:

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-orm</artifactId>
    <version>5.3.12</version>
</dependency>
<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-core</artifactId>
    <version>5.6.1.Final</version>
</dependency>
<dependency>
    <groupId>javax.transaction</groupId>
    <artifactId>javax.transaction-api</artifactId>
    <version>1.3</version>
</dependency>

ডাটাবেস কনফিগারেশন

Spring এবং Hibernate এর মধ্যে সংযোগ স্থাপনের জন্য কনফিগারেশন ফাইল তৈরি করতে হবে।

Spring Configuration (XML):

<bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource">
    <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/yourdb"/>
    <property name="username" value="root"/>
    <property name="password" value="password"/>
</bean>

<bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
    <property name="dataSource" ref="dataSource"/>
    <property name="packagesToScan" value="com.example.entity"/>
    <property name="hibernateProperties">
        <props>
            <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</prop>
        </props>
    </property>
</bean>

<bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
    <property name="sessionFactory" ref="sessionFactory"/>
</bean>

মডেল ক্লাস তৈরি করা

Example Entity Class:

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;

    @Column(name = "name")
    private String name;

    @Column(name = "email")
    private String email;

    // Getters and Setters
}

DAO লেয়ার তৈরি করা

DAO লেয়ারে Hibernate এর SessionFactory ব্যবহার করে CRUD অপারেশন পরিচালনা করা হয়।

Example DAO Class:

@Repository
public class UserDao {
    @Autowired
    private SessionFactory sessionFactory;

    // Create
    public void saveUser(User user) {
        Session session = sessionFactory.getCurrentSession();
        session.save(user);
    }

    // Read
    public User getUserById(int id) {
        Session session = sessionFactory.getCurrentSession();
        return session.get(User.class, id);
    }

    // Update
    public void updateUser(User user) {
        Session session = sessionFactory.getCurrentSession();
        session.update(user);
    }

    // Delete
    public void deleteUser(int id) {
        Session session = sessionFactory.getCurrentSession();
        User user = session.byId(User.class).load(id);
        session.delete(user);
    }
}

সার্ভিস লেয়ার তৈরি করা

DAO লেয়ারকে ব্যবহারের জন্য সার্ভিস লেয়ার তৈরি করতে হবে।

Example Service Class:

@Service
@Transactional
public class UserService {
    @Autowired
    private UserDao userDao;

    public void createUser(User user) {
        userDao.saveUser(user);
    }

    public User findUserById(int id) {
        return userDao.getUserById(id);
    }

    public void modifyUser(User user) {
        userDao.updateUser(user);
    }

    public void removeUser(int id) {
        userDao.deleteUser(id);
    }
}

কন্ট্রোলার লেয়ার তৈরি করা

Spring MVC বা REST API ব্যবহার করে কন্ট্রোলার লেয়ার তৈরি করা হয়।

Example Controller Class:

@RestController
@RequestMapping("/users")
public class UserController {
    @Autowired
    private UserService userService;

    @PostMapping("/create")
    public ResponseEntity<String> createUser(@RequestBody User user) {
        userService.createUser(user);
        return ResponseEntity.ok("User created successfully");
    }

    @GetMapping("/{id}")
    public ResponseEntity<User> getUser(@PathVariable int id) {
        User user = userService.findUserById(id);
        return ResponseEntity.ok(user);
    }

    @PutMapping("/update")
    public ResponseEntity<String> updateUser(@RequestBody User user) {
        userService.modifyUser(user);
        return ResponseEntity.ok("User updated successfully");
    }

    @DeleteMapping("/delete/{id}")
    public ResponseEntity<String> deleteUser(@PathVariable int id) {
        userService.removeUser(id);
        return ResponseEntity.ok("User deleted successfully");
    }
}

Spring ORM এবং Hibernate এর মাধ্যমে CRUD অপারেশন সহজ এবং কার্যকরভাবে সম্পন্ন করা যায়। লেয়ারড আর্কিটেকচার এবং ট্রানজেকশন ম্যানেজমেন্টের সাহায্যে অ্যাপ্লিকেশন আরও সুনিয়ন্ত্রিত হয়।

Spring ORM (Object Relational Mapping) হল Spring Framework এর একটি মডিউল, যা Hibernate এর মতো ORM টুলের সাথে ইন্টিগ্রেট করে ডেটাবেজ অপারেশন সহজতর করে। Spring ORM ডেটাবেজ অপারেশনের জন্য Spring এর Transaction Management এবং Dependency Injection সুবিধা প্রদান করে।

CRUD অপারেশন বলতে বোঝানো হয় ডেটাবেজের চারটি মৌলিক কার্যক্রম:

• Create: নতুন ডেটা সংযোজন
• Read: বিদ্যমান ডেটা পড়া
• Update: বিদ্যমান ডেটা পরিবর্তন
• Delete: ডেটা মুছে ফেলা

Spring ORM এই CRUD অপারেশনগুলো Hibernate বা JPA এর সাহায্যে খুবই সহজে বাস্তবায়ন করতে পারে।

CRUD অপারেশন: বিস্তারিত

Create (ডেটা সংযোজন)

Create অপারেশন ব্যবহার করে নতুন ডেটা ডেটাবেজে ইনসার্ট করা হয়। Hibernate এর save() বা JPA এর persist() মেথড ব্যবহার করে এটি সম্পন্ন করা হয়।

@Transactional
public void createEmployee(Employee employee) {
    sessionFactory.getCurrentSession().save(employee);
}

Read (ডেটা পড়া)

Read অপারেশন ব্যবহার করে ডেটাবেজ থেকে ডেটা রিট্রিভ করা হয়। Hibernate এ get() বা load() এবং JPA তে find() মেথড ব্যবহার করা হয়।

@Transactional
public Employee getEmployeeById(int id) {
    return sessionFactory.getCurrentSession().get(Employee.class, id);
}

Update (ডেটা পরিবর্তন)

Update অপারেশন বিদ্যমান ডেটার পরিবর্তন করার জন্য ব্যবহৃত হয়। Hibernate এ update() বা JPA তে merge() মেথড ব্যবহার করা হয়।

@Transactional
public void updateEmployee(Employee employee) {
    sessionFactory.getCurrentSession().update(employee);
}

Delete (ডেটা মুছে ফেলা)

Delete অপারেশন ব্যবহার করে ডেটাবেজ থেকে ডেটা মুছে ফেলা হয়। Hibernate এ delete() এবং JPA তে remove() মেথড ব্যবহার করা হয়।

@Transactional
public void deleteEmployee(int id) {
    Employee employee = sessionFactory.getCurrentSession().get(Employee.class, id);
    if (employee != null) {
        sessionFactory.getCurrentSession().delete(employee);
    }
}

Spring ORM এবং Transaction Management

Spring ORM এ CRUD অপারেশনগুলো @Transactional অ্যানোটেশন ব্যবহার করে টানজেকশন নিরাপত্তার সাথে সম্পন্ন করা যায়। এর ফলে ট্রানজেকশন ব্যর্থ হলে ডেটাবেজের ডেটা রোলব্যাক হয়, যা ডেটার অখণ্ডতা বজায় রাখে।

উদাহরণ:

@Service
public class EmployeeService {

    @Autowired
    private SessionFactory sessionFactory;

    @Transactional
    public void saveEmployee(Employee employee) {
        sessionFactory.getCurrentSession().save(employee);
    }
    
    @Transactional
    public Employee findEmployeeById(int id) {
        return sessionFactory.getCurrentSession().get(Employee.class, id);
    }
    
    @Transactional
    public void updateEmployee(Employee employee) {
        sessionFactory.getCurrentSession().update(employee);
    }
    
    @Transactional
    public void deleteEmployee(int id) {
        Employee employee = sessionFactory.getCurrentSession().get(Employee.class, id);
        if (employee != null) {
            sessionFactory.getCurrentSession().delete(employee);
        }
    }
}

Spring ORM এবং Hibernate এর মাধ্যমে CRUD অপারেশন সহজতর, কার্যকর এবং ডেটাবেজ-স্বাধীনভাবে পরিচালনা করা যায়।

স্প্রিং ওআরএম (Spring ORM) হলো স্প্রিং ফ্রেমওয়ার্কের একটি মডিউল যা Object Relational Mapping (ORM) প্রযুক্তি যেমন Hibernate এবং Java Persistence API (JPA) ব্যবহার করে ডেটাবেস অপারেশনগুলো সহজ করে। CRUD অপারেশনগুলো (Create, Read, Update, Delete) পরিচালনার জন্য স্প্রিং ORM এবং JPA একটি শক্তিশালী সমাধান প্রদান করে।

JPA এবং Hibernate পরিচিতি

JPA (Java Persistence API)

JPA হলো একটি স্পেসিফিকেশন, যা ডেটাবেজের সাথে কাজ করার জন্য কিছু স্ট্যান্ডার্ড নির্দেশনা দেয়। এটি ইমপ্লিমেন্ট করার জন্য Hibernate একটি জনপ্রিয় ফ্রেমওয়ার্ক।

Hibernate

Hibernate হলো JPA-এর একটি ইমপ্লিমেন্টেশন। এটি জাভা অবজেক্ট এবং ডেটাবেসের মধ্যে ম্যাপিং সহজ করার জন্য ব্যবহৃত হয়।

স্প্রিং ORM দিয়ে JPA/Hibernate ইন্টিগ্রেশন

ডিপেন্ডেন্সি সংযোজন

Maven ব্যবহার করলে নিচের ডিপেন্ডেন্সিগুলো pom.xml ফাইলে যুক্ত করতে হবে:

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
</dependencies>

স্প্রিং ORM কনফিগারেশন

Application.properties ফাইল

application.properties ফাইলে ডাটাবেস কনফিগারেশন যুক্ত করুন:

spring.datasource.url=jdbc:mysql://localhost:3306/your_database
spring.datasource.username=your_username
spring.datasource.password=your_password
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL8Dialect

CRUD অপারেশন ইমপ্লিমেন্টেশন

Entity ক্লাস তৈরি

JPA ব্যবহার করে ডেটাবেস টেবিলের জন্য একটি Entity ক্লাস তৈরি করুন। উদাহরণস্বরূপ:

@Entity
@Table(name = "employees")
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "name", nullable = false)
    private String name;

    @Column(name = "department")
    private String department;

    @Column(name = "salary")
    private double salary;

    // Getters and Setters
}

Repository ইন্টারফেস তৈরি

Spring Data JPA-এর সাহায্যে JpaRepository ইন্টারফেস ব্যবহার করে ডেটাবেজ অপারেশনগুলো সহজ করা যায়:

@Repository
public interface EmployeeRepository extends JpaRepository<Employee, Long> {
}

সার্ভিস স্তর তৈরি

ব্যবসায়িক লজিক পরিচালনার জন্য সার্ভিস ক্লাস তৈরি করুন:

@Service
public class EmployeeService {
    @Autowired
    private EmployeeRepository employeeRepository;

    public Employee saveEmployee(Employee employee) {
        return employeeRepository.save(employee);
    }

    public Employee getEmployeeById(Long id) {
        return employeeRepository.findById(id).orElse(null);
    }

    public List<Employee> getAllEmployees() {
        return employeeRepository.findAll();
    }

    public Employee updateEmployee(Long id, Employee employeeDetails) {
        Employee existingEmployee = employeeRepository.findById(id).orElse(null);
        if (existingEmployee != null) {
            existingEmployee.setName(employeeDetails.getName());
            existingEmployee.setDepartment(employeeDetails.getDepartment());
            existingEmployee.setSalary(employeeDetails.getSalary());
            return employeeRepository.save(existingEmployee);
        }
        return null;
    }

    public void deleteEmployee(Long id) {
        employeeRepository.deleteById(id);
    }
}

কন্ট্রোলার স্তর তৈরি

REST API তৈরি করতে কন্ট্রোলার ক্লাস ব্যবহার করুন:

@RestController
@RequestMapping("/api/employees")
public class EmployeeController {
    @Autowired
    private EmployeeService employeeService;

    @PostMapping
    public Employee createEmployee(@RequestBody Employee employee) {
        return employeeService.saveEmployee(employee);
    }

    @GetMapping("/{id}")
    public Employee getEmployeeById(@PathVariable Long id) {
        return employeeService.getEmployeeById(id);
    }

    @GetMapping
    public List<Employee> getAllEmployees() {
        return employeeService.getAllEmployees();
    }

    @PutMapping("/{id}")
    public Employee updateEmployee(@PathVariable Long id, @RequestBody Employee employee) {
        return employeeService.updateEmployee(id, employee);
    }

    @DeleteMapping("/{id}")
    public void deleteEmployee(@PathVariable Long id) {
        employeeService.deleteEmployee(id);
    }
}

সারাংশ

স্প্রিং ORM ব্যবহার করে JPA এবং Hibernate এর মাধ্যমে CRUD অপারেশন ইমপ্লিমেন্ট করা খুবই সহজ এবং কার্যকর। JPA-এর স্ট্যান্ডার্ড স্পেসিফিকেশন এবং Hibernate-এর শক্তিশালী ORM ফিচার একত্রে ব্যবহার করে ডেটাবেস অপারেশন পরিচালনা করা যায়, যা অ্যাপ্লিকেশনকে আরও স্কেলেবল এবং মেইনটেইনেবল করে।

Spring ORM ব্যবহার করে Java-তে ডাটাবেসের সঙ্গে CRUD (Create, Read, Update, Delete) অপারেশন সহজেই বাস্তবায়ন করা যায়। Hibernate ORM ফ্রেমওয়ার্ক এবং Spring-এর Transaction Management ব্যবহারের মাধ্যমে এটি করা হয়। নিচে উদাহরণ সহ ব্যাখ্যা দেওয়া হলো।

প্রাথমিক কনফিগারেশন

Maven ডিপেনডেন্সি

প্রথমে প্রকল্পে Hibernate এবং Spring ORM-এর ডিপেনডেন্সি যোগ করতে হবে:

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-orm</artifactId>
    <version>YOUR_SPRING_VERSION</version>
</dependency>
<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-core</artifactId>
    <version>YOUR_HIBERNATE_VERSION</version>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>YOUR_MYSQL_VERSION</version>
</dependency>

Hibernate Configuration

Hibernate Configuration ফাইল hibernate.cfg.xml উদাহরণ:

<hibernate-configuration>
    <session-factory>
        <property name="hibernate.connection.driver_class">com.mysql.cj.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/spring_orm_demo</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">password</property>
        <property name="hibernate.dialect">org.hibernate.dialect.MySQL8Dialect</property>
        <property name="hibernate.show_sql">true</property>
        <property name="hibernate.hbm2ddl.auto">update</property>
    </session-factory>
</hibernate-configuration>

মডেল ক্লাস তৈরি

উদাহরণস্বরূপ, একটি Employee ক্লাস তৈরি করা হলো:

package com.example.model;

import jakarta.persistence.*;

@Entity
@Table(name = "employees")
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "name")
    private String name;

    @Column(name = "department")
    private String department;

    @Column(name = "salary")
    private Double salary;

    // Getters and Setters
}

DAO (Data Access Object) তৈরি

Spring ORM এ DAO ক্লাস Hibernate ব্যবহার করে ডাটাবেস অপারেশন পরিচালনা করে।

package com.example.dao;

import com.example.model.Employee;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
public class EmployeeDao {

    @Autowired
    private SessionFactory sessionFactory;

    public void save(Employee employee) {
        Session session = sessionFactory.getCurrentSession();
        session.save(employee);
    }

    public Employee getById(Long id) {
        Session session = sessionFactory.getCurrentSession();
        return session.get(Employee.class, id);
    }

    public List<Employee> getAll() {
        Session session = sessionFactory.getCurrentSession();
        return session.createQuery("from Employee", Employee.class).list();
    }

    public void update(Employee employee) {
        Session session = sessionFactory.getCurrentSession();
        session.update(employee);
    }

    public void delete(Long id) {
        Session session = sessionFactory.getCurrentSession();
        Employee employee = session.get(Employee.class, id);
        if (employee != null) {
            session.delete(employee);
        }
    }
}

সার্ভিস ক্লাস তৈরি

DAO ক্লাসের ওপর ভিত্তি করে সার্ভিস লেয়ার তৈরি করা হয়:

package com.example.service;

import com.example.dao.EmployeeDao;
import com.example.model.Employee;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Service
@Transactional
public class EmployeeService {

    @Autowired
    private EmployeeDao employeeDao;

    public void saveEmployee(Employee employee) {
        employeeDao.save(employee);
    }

    public Employee getEmployeeById(Long id) {
        return employeeDao.getById(id);
    }

    public List<Employee> getAllEmployees() {
        return employeeDao.getAll();
    }

    public void updateEmployee(Employee employee) {
        employeeDao.update(employee);
    }

    public void deleteEmployee(Long id) {
        employeeDao.delete(id);
    }
}

Spring Configuration

Spring Configuration এ Hibernate SessionFactory Bean তৈরি করতে হবে:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.orm.hibernate5.LocalSessionFactoryBean;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.sql.DataSource;
import org.springframework.jdbc.datasource.DriverManagerDataSource;

@Configuration
@EnableTransactionManagement
public class AppConfig {

    @Bean
    public DataSource dataSource() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/spring_orm_demo");
        dataSource.setUsername("root");
        dataSource.setPassword("password");
        return dataSource;
    }

    @Bean
    public LocalSessionFactoryBean sessionFactory() {
        LocalSessionFactoryBean sessionFactory = new LocalSessionFactoryBean();
        sessionFactory.setDataSource(dataSource());
        sessionFactory.setPackagesToScan("com.example.model");
        return sessionFactory;
    }
}

CRUD অপারেশন পরীক্ষা করা

Spring এর সাহায্যে CRUD অপারেশন চালানোর জন্য নিচে একটি Main ক্লাস উদাহরণ দেওয়া হলো:

package com.example;

import com.example.model.Employee;
import com.example.service.EmployeeService;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Main {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = 
                new AnnotationConfigApplicationContext(AppConfig.class);

        EmployeeService employeeService = context.getBean(EmployeeService.class);

        // Create
        Employee employee = new Employee();
        employee.setName("John Doe");
        employee.setDepartment("IT");
        employee.setSalary(50000.0);
        employeeService.saveEmployee(employee);

        // Read
        Employee fetchedEmployee = employeeService.getEmployeeById(employee.getId());
        System.out.println("Fetched Employee: " + fetchedEmployee.getName());

        // Update
        fetchedEmployee.setSalary(60000.0);
        employeeService.updateEmployee(fetchedEmployee);

        // Delete
        employeeService.deleteEmployee(fetchedEmployee.getId());

        context.close();
    }
}

Spring ORM এবং Hibernate ব্যবহার করে এভাবে CRUD অপারেশন সহজেই বাস্তবায়ন করা যায়। এই উদাহরণ ডাটাবেসের সঙ্গে ইন্টিগ্রেশন এবং স্প্রিং এর শক্তিশালী ফিচার ব্যবহার করে উন্নত অ্যাপ্লিকেশন তৈরির জন্য একটি মডেল হিসেবে কাজ করে।